js_parser: bind import X = A.B to the enum or namespace it names - #47708

Self-review. A review of this diff said not to merge it as it is, and to ask the question above first. I checked each reason below.

• No user reported the shapes. A fuzzer found them.
• The two maintainer statements on this code ask about esbuild: the review of fix(transpiler): fold const enum members that reference const variables #27167 ("Read over esbuild's implementation and understand what they do") and the question on js_printer: parenthesize inlined negative enum value on LHS of ** #36133 ("is this exactly what esbuild does?"). esbuild 0.28.2 prints void 0 for all seven shapes.
• Get a wrong build result when first element of typescript enum is not a Literal value  evanw/esbuild#3868 names tsc's emit for an isolated module as esbuild's reference for this arm. ts.transpileModule 6.0.2 prints 3 4 for all seven shapes, so option 1 follows that reference. The same issue refuses option 2 for a read of another file.
• The value is written by the last else of s_enum (src/js_parser/visit/visit_stmt.rs:2417), and this PR changes nothing there. const a = 3; enum Y { P = a, R } (the kind of initializer in Constant folding is not working inside const enum #19581) reaches the same arm and prints 3 undefined on main and on this branch. For the smallest shape, oxc-transform 0.156.0 prints Y["R"] = 1 + Y["P"] and sucrase 3.35.1 prints const R = P + 1.
• Other open pull requests enter the same arm one kind at a time: js_parser: fold references to const variables in enum initializers #42004, js_parser: fold enum members nested in an earlier namespace into enum initializers #42118, js_parser: fold a number const named by an enum initializer, on demand from s_enum #46693 and js_parser: register the closure argument of a TypeScript namespace block #46938. js_printer: parenthesize inlined negative enum value on LHS of ** #36133, js_printer: parenthesize the folded import.meta.main node and the left operand of ** by level #33447 and js_printer: inline a cross-module enum member only where the parser counted a read #42454 change the printer for a value that is inlined.
• The order the review proposes for option 1: the ** printer fix alone (js_printer: parenthesize inlined negative enum value on LHS of ** #36133 or js_printer: parenthesize the folded import.meta.main node and the left operand of ** by level #33447), then js_parser: register the closure argument of a TypeScript namespace block #46938, then this PR rebased with no printer lines.

Defects the review found, not fixed yet. Checked on release builds of main 3f3a9ff and of 57d7b77.

• The alias statement does not always stay. The four lines enum Z { Q = 3 }, import X = Z;, X.Q; and console.log(eval("X.Q")) print 3 on main. This branch throws ReferenceError: X is not defined under bun run: the folded statement is removed, its part gives the use back, and the alias has no use left. bun build --no-bundle keeps the statement.
• bun run and a --aot executable disagree on two shapes where main agrees.
  • namespace M { export function F() {} export namespace F { export enum E { A = 1 } } } import X = M.F.E; namespace N { export enum Y { P = X.A, R } } prints 1 undefined under bun run and 1 2 in the executable. Main prints 1 undefined in both.
  • namespace Outer { export namespace N { export enum Z { Q = 3 } } import A = N.Z; export namespace Later { export enum W { P = A.Q, R } } } prints 3 4 under bun run and 3 undefined in the executable. Main prints 3 undefined in both.
• An importer's write. With export enum Y { P = X.Q, R } in one file, (Y as any).P = 14 in an importer bundles to Y.P = 14 on main and to 3 /* P */ = 14 here, which does not parse. Main prints the same text when the member is P = Z.Q. js_printer: inline a cross-module enum member only where the parser counted a read #42454 changes that printer path.
• For a rework: use find_symbol_with_record_usage::<false> in place of the copy in find_ts_name_binding. Bind in one pass in source order, or pin the cycle guard with tests (import A = B; import B = A). Add tests with treeShaking and minify.syntax, and for exports.replace. Use it.failing rows in place of the rows that pin R: undefined.

Corrections to earlier text of this description.

• The tsc values below come from createProgram. ts.transpileModule (one file at a time) gives the same 3 4 for the seven shapes.
• js_parser: fold enum members nested in an earlier namespace into enum initializers #42118 does not own the three rows that stay. It is stacked on js_parser: fold references to const variables in enum initializers #42004, which conflicts with main.
• The chain written leaf first (import W = X; import X = A.Z) still throws under bun run and --no-bundle. Under bun build it now prints 3 4, because the bundler drops the unused const W = X. No test pins that. js_parser: remove unused TS import-equals before the import scan, and scan each Part once #36143 does not change how the statement is printed.
• A read through the alias folds in its own file only. An importer of export import X = Z keeps X.Q as a run-time read, as on main.
• The cost of an alias depends on its first name: +279 instructions when nothing binds it (9,827 to 10,106), and +599 when a const or a require import binds it (3,412 to 4,011).

Where it comes from. A fuzzer found the shapes. No user reported them. The values below are from Bun.Transpiler output run with new Function, and tsc 6.0.2 through createProgram.

The three rows that stay are the visit order: bun visits a top-level enum before the body of namespace A, so the members of A.Z have no values yet. The direct name enum Y { P = A.Z.Q, R } gives 3 undefined on main for the same reason. #42118 changes that order (see the corrections above). Three it.todo rows hold tsc's values.

What else folds. X['Q'], X.Q + 1, -X.Q, a string member (no reverse key, as tsc), a merged enum, an alias of a namespace or of a nested namespace, a module-level export import X = Z, the inner of two aliases of one name, and a read outside an enum (const x = X.Q). A bundle that imports Y gets its members as numbers (ts/ImportEqualsEnumAlias).

Not in this change. Each line prints as on main. it.todo rows hold tsc's values.

• export import X = Z inside a namespace: the bare read in its block, the bare read from a sibling block, M.X.Q from outside, and import W = M.X. The bare name of such an export has no local binding to print.
• An alias of a member read as a bare name: import X = Z.Q; enum Y { P = X, R }.
• An alias of an alias that is written behind it (import W = X; import X = A.Z). The enum folds, but the kept const W = X still throws at run time under bun run and --no-bundle, as on main (see the corrections above). tsc prints var.
• A nearer binding with the name of the alias (function f(X) { enum Y { P = X.Q, R } }). tsc folds past the parameter. bun binds the parameter, on purpose.
• X?.Q does not fold, like Z?.Q.
• A top-level alias statement whose every read folded is not dropped. tsc drops it when it compiles a program, and keeps it per file.

The --aot checker. resolve_member_path (src/sema/check/aot/enum_constants.rs) says which enum reads the transpiler replaces by values. It refused every first name that is an alias. is_first_name_followed now follows an entity alias that no namespace exports, whose first name is an enum or a namespace of the file, an export of another part of its namespace, or another such alias. A probe compares 25 alias reads in the transpiler's output with the checker's answers: 24 agree. The last one is an alias through a namespace that shares a block with a function of its name (import X = M.F): the checker follows it and the transpiler does not, as for the direct path M.F.E.A on main. #46938 has the rule for that shape.

Overlaps.

• js_parser: register the closure argument of a TypeScript namespace block #46938 (a bare name that a sibling namespace block exports): the cache version, the one printer line for a member of the same file, the same function of enum_constants.rs, and the same place in narrowing.programs. The second of the two to land rebases.
• js_parser: stop storing Property under a symbol ref in the namespace export loop #47001: stores Property in the namespace export loop. No line in common.
• js_printer: parenthesize inlined negative enum value on LHS of ** #36133: the ** printer arm. The lines for a member of another module are here because this fold can make such a member a negative constant: without them Y.P ** 2 in an importing module prints -3 /* P */ ** 2, a SyntaxError, where main printed 9.
• js_parser: fold enum members nested in an earlier namespace into enum initializers #42118 and js_parser: fold references to const variables in enum initializers #42004: the visit order and the fold of a const, see above.
• js_parser: fold a number const named by an enum initializer, on demand from s_enum #46693, js_printer: inline a cross-module enum member only where the parser counted a read #42454 and js_printer: parenthesize the folded import.meta.main node and the left operand of ** by level #33447: other entrances to the same arm of s_enum and other edits of the printer arms for an inlined value.
• js_parser: remove unused TS import-equals before the import scan, and scan each Part once #36143 (draft) and typescript: match tsc for experimentalDecorators and emitDecoratorMetadata #46553: both edit parse_type_script_import_equals_stmt.

Measurements. Release builds of main 3f3a9ff and of 57d7b77 in one container. The commit after 57d7b77 only turns the method find_ts_name_binding into a free function. Instructions are user-mode counts.

• Bytes by function (nm -S): handle_identifier, find_symbol_with_record_usage, maybe_rewrite_property_access, maybe_rewrite_property_access_for_namespace, s_enum and visit_stmts are identical in every instantiation. New bind_ts_import_equals_aliases 4,591 (one copy). P::init +10 in each of four copies. parse_type_script_import_equals_stmt +111 and +97. parse_type_script_namespace_stmt +26 in two copies. _parse::<true> +33. print_expr -338 to +465 in five copies, and prints_as_imported_enum_value 191 in five copies. Checker: is_first_name_followed 3,131, resolve_member_path +64, is_declared_around (457) inlined.
• The slopes are whole-process counts of bun build --no-bundle from perf_event_open, minimum of 5 runs, spread under 700. The chain of 100,000 aliases written leaf first resolves (console.log(3 /* Q */)) with no recursion.
• Output on existing code: 24 of 76,434 outputs differ between the two builds. That is 12,740 tracked .ts, .tsx, .mts and .cts files under six Bun.Transpiler option sets (default, inline with target bun, minify.syntax, all of minify, treeShaking with trimUnusedImports, deadCodeElimination off). The 24 are four programs of test/aot/parallel/enums under each set: three read an enum through an alias, and one has a negative member left of **. The alias statements of those files are printed as before (2 and 7).
• --aot parity: test/aot/run-parallel.ts with the release build passes 24 of 24 programs of test/aot/parallel/enums, compiled and with --aot-erase-types. enums-namespaces-read-paths-brackets.ts reads 8 members through aliases on 3 lines: plain Bun and the executable now both print the values.
• Runtime transpiler cache, a 146 KB file: the first run of this build writes the entry again (version 51 to 52) and prints 3 4 where main printed 3 undefined. The second run reads it.

Tests. transpiler.test.js: 38 new tests and 9 it.todo rows. 23 of the 38 fail on main, and 15 pin what must not change. ts/ImportEqualsEnumAlias fails on main. checker-queries-narrowing.test.ts: 38 pass, one new fixture (enum-access-import-equals). New program test/aot/parallel/enums/enum-read-through-import-equals-alias.ts.

Also ran (debug build, all pass): the rest of transpiler.test.js and esbuild/ts.test.ts, esbuild/{importstar_ts,dce}, bundler_edgecase, transpiler/runtime-transpiler, cli/run/transpiler-cache.